home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1994 November: Tool Chest / Dev.CD Nov 94.toast / Tool Chest / !Interfaces / Universal Interfaces 2.0a1 / PInterfaces / DatabaseAccess.p < prev    next >
Encoding:
Text File  |  1994-07-17  |  10.8 KB  |  321 lines  |  [TEXT/MPS ]
  1. {
  2.      File:        DatabaseAccess.p
  3.  
  4.      Copyright:    © 1984-1994 by Apple Computer, Inc.
  5.                  All rights reserved.
  6.  
  7.      Version:    Universal Interfaces 2.0a1.  ETO #15, MPW prerelease.  Sunday, July 17, 1994. 
  8.  
  9.      Bugs?:        If you find a problem with this file, send the file and version
  10.                  information (from above) and the problem description to:
  11.  
  12.                      Internet:    apple.bugs@applelink.apple.com
  13.                      AppleLink:    APPLE.BUGS
  14.  
  15. }
  16.  
  17. {$IFC UNDEFINED UsingIncludes}
  18. {$SETC UsingIncludes := 0}
  19. {$ENDC}
  20.  
  21. {$IFC NOT UsingIncludes}
  22.  UNIT DatabaseAccess;
  23.  INTERFACE
  24. {$ENDC}
  25.  
  26. {$IFC UNDEFINED __DATABASEACCESS__}
  27. {$SETC __DATABASEACCESS__ := 1}
  28.  
  29. {$I+}
  30. {$SETC DatabaseAccessIncludes := UsingIncludes}
  31. {$SETC UsingIncludes := 1}
  32.  
  33.  
  34. {$IFC UNDEFINED __RESOURCES__}
  35. {$I Resources.p}
  36. {$ENDC}
  37. {    Types.p                                                        }
  38. {        ConditionalMacros.p                                        }
  39. {    MixedMode.p                                                    }
  40. {    Files.p                                                        }
  41. {        OSUtils.p                                                }
  42.  
  43. {$PUSH}
  44. {$ALIGN MAC68K}
  45. {$LibExport+}
  46.  
  47. CONST
  48.     typeNone                    = 'none';
  49.     typeDate                    = 'date';
  50.     typeTime                    = 'time';
  51.     typeTimeStamp                = 'tims';
  52.     typeDecimal                    = 'deci';
  53.     typeMoney                    = 'mone';
  54.     typeVChar                    = 'vcha';
  55.     typeVBin                    = 'vbin';
  56.     typeLChar                    = 'lcha';
  57.     typeLBin                    = 'lbin';
  58.     typeDiscard                    = 'disc';
  59. { "dummy" types for DBResultsToText }
  60.     typeUnknown                    = 'unkn';
  61.     typeColBreak                = 'colb';
  62.     typeRowBreak                = 'rowb';
  63. { pass this in to DBGetItem for any data type }
  64.     typeAnyType                    = 0;
  65.  
  66. { infinite timeout value for DBGetItem }
  67. { messages for status functions for DBStartQuery }
  68.     kDBUpdateWind                = 0;
  69.     kDBAboutToInit                = 1;
  70.     kDBInitComplete                = 2;
  71.     kDBSendComplete                = 3;
  72.     kDBExecComplete                = 4;
  73.     kDBStartQueryComplete        = 5;
  74.  
  75. { messages for status functions for DBGetQueryResults }
  76.     kDBGetItemComplete            = 6;
  77.     kDBGetQueryResultsComplete    = 7;
  78.     kDBWaitForever                = -1;
  79. {  flags for DBGetItem  }
  80.     kDBLastColFlag                = $0001;
  81.     kDBNullFlag                    = $0004;
  82.  
  83.     
  84. TYPE
  85. DBType = OSType;
  86.  
  87.     DBAsyncParmBlkPtr = ^DBAsyncParamBlockRec;
  88.  
  89.     {
  90.         DBCompletionProcPtr uses register based parameters on the 68k and cannot
  91.         be written in or called from a high-level language without the help of
  92.         mixed mode or assembly glue.
  93.  
  94.         In:
  95.          => pb              A1.L
  96.     }
  97.     DBCompletionProcPtr = ProcPtr;  { PROCEDURE DBCompletion(pb: DBAsyncParmBlkPtr); }
  98.     DBCompletionUPP = UniversalProcPtr;
  99.  
  100.     DBAsyncParamBlockRec = RECORD
  101.         completionProc:            DBCompletionUPP;                        { pointer to completion routine }
  102.         result:                    OSErr;                                    { result of call }
  103.         userRef:                LONGINT;                                { for application's use }
  104.         ddevRef:                LONGINT;                                { for ddev's use }
  105.         reserved:                LONGINT;                                { for internal use }
  106.     END;
  107. CONST
  108.     uppDBCompletionProcInfo = $0000B802; { Register PROCEDURE (4 bytes in A1); }
  109.  
  110. PROCEDURE CallDBCompletionProc(pb: DBAsyncParmBlkPtr; userRoutine: DBCompletionUPP);
  111.     {$IFC NOT GENERATINGCFM}
  112.     {To be implemented:  Glue to move parameters into registers.}
  113.     {$ENDC}
  114.  
  115. FUNCTION NewDBCompletionProc(userRoutine: DBCompletionProcPtr): DBCompletionUPP;
  116.     {$IFC NOT GENERATINGCFM }
  117.     INLINE $2E9F;
  118.     {$ENDC}
  119.  
  120. TYPE
  121.     ResListElem = RECORD
  122.         theType:                ResType;                                { resource type }
  123.         id:                        INTEGER;                                { resource id }
  124.     END;
  125.     ResListPtr = ^ResListElem;
  126.     ResListHandle = ^ResListPtr;
  127.  
  128. { structure for query list in QueryRecord }
  129.     QueryArray = ARRAY [0..255] OF Handle;
  130.  
  131.     QueryList = QueryArray;
  132.     QueryListPtr = ^QueryArray;
  133.     QueryListHandle = ^QueryListPtr;
  134.  
  135.     QueryRecord = RECORD
  136.         version:                INTEGER;                                { version }
  137.         id:                        INTEGER;                                { id of 'qrsc' this came from }
  138.         queryProc:                Handle;                                    { handle to query def proc }
  139.         ddevName:                Str63;                                    { ddev name }
  140.         host:                    Str255;                                    { host name }
  141.         user:                    Str255;                                    { user name }
  142.         password:                Str255;                                    { password }
  143.         connStr:                Str255;                                    { connection string }
  144.         currQuery:                INTEGER;                                { index of current query }
  145.         numQueries:                INTEGER;                                { number of queries in list }
  146.         queryList:                QueryListHandle;                        { handle to array of handles to text }
  147.         numRes:                    INTEGER;                                { number of resources in list }
  148.         resList:                ResListHandle;                            { handle to array of resource list elements }
  149.         dataHandle:                Handle;                                    { for use by query def proc }
  150.         refCon:                    LONGINT;                                { for use by application }
  151.     END;
  152.     QueryPtr = ^QueryRecord;
  153.     QueryHandle = ^QueryPtr;
  154.  
  155. { structure of column types array in ResultsRecord }
  156.     ColTypesArray = ARRAY [0..255] OF DBType;
  157.  
  158.     ColTypesPtr = ^ColTypesArray;
  159.     ColTypesHandle = ^ColTypesPtr;
  160.  
  161. { structure for column info in ResultsRecord }
  162.     DBColInfoRecord = RECORD
  163.         len:                    INTEGER;
  164.         places:                    INTEGER;
  165.         flags:                    INTEGER;
  166.     END;
  167.     ColInfoArray = ARRAY [0..255] OF DBColInfoRecord;
  168.  
  169.     ColInfoPtr = ^ColInfoArray;
  170.     ColInfoHandle = ^ColInfoPtr;
  171.  
  172. { structure of results returned by DBGetResults }
  173.     ResultsRecord = RECORD
  174.         numRows:                INTEGER;                                { number of rows in result }
  175.         numCols:                INTEGER;                                { number of columns per row }
  176.         colTypes:                ColTypesHandle;                            { data type array }
  177.         colData:                Handle;                                    { actual results }
  178.         colInfo:                ColInfoHandle;                            { DBColInfoRecord array }
  179.     END;
  180.     DBQueryDefProcPtr = ProcPtr;  { FUNCTION DBQueryDef(VAR sessID: LONGINT; query: QueryHandle): OSErr; }
  181.     DBStatusProcPtr = ProcPtr;  { FUNCTION DBStatus(message: INTEGER; result: OSErr; dataLen: INTEGER; dataPlaces: INTEGER; dataFlags: INTEGER; dataType: DBType; dataPtr: Ptr): BOOLEAN; }
  182.     DBResultHandlerProcPtr = ProcPtr;  { FUNCTION DBResultHandler(dataType: DBType; theLen: INTEGER; thePlaces: INTEGER; theFlags: INTEGER; theData: Ptr; theText: Handle): OSErr; }
  183.     DBQueryDefUPP = UniversalProcPtr;
  184.     DBStatusUPP = UniversalProcPtr;
  185.     DBResultHandlerUPP = UniversalProcPtr;
  186.  
  187. CONST
  188.     uppDBQueryDefProcInfo = $000003E0; { FUNCTION (4 byte param, 4 byte param): 2 byte result; }
  189.     uppDBStatusProcInfo = $000FAA90; { FUNCTION (2 byte param, 2 byte param, 2 byte param, 2 byte param, 2 byte param, 4 byte param, 4 byte param): 1 byte result; }
  190.     uppDBResultHandlerProcInfo = $0003EAE0; { FUNCTION (4 byte param, 2 byte param, 2 byte param, 2 byte param, 4 byte param, 4 byte param): 2 byte result; }
  191.  
  192. FUNCTION NewDBQueryDefProc(userRoutine: DBQueryDefProcPtr): DBQueryDefUPP;
  193.     {$IFC NOT GENERATINGCFM }
  194.     INLINE $2E9F;
  195.     {$ENDC}
  196.  
  197. FUNCTION NewDBStatusProc(userRoutine: DBStatusProcPtr): DBStatusUPP;
  198.     {$IFC NOT GENERATINGCFM }
  199.     INLINE $2E9F;
  200.     {$ENDC}
  201.  
  202. FUNCTION NewDBResultHandlerProc(userRoutine: DBResultHandlerProcPtr): DBResultHandlerUPP;
  203.     {$IFC NOT GENERATINGCFM }
  204.     INLINE $2E9F;
  205.     {$ENDC}
  206.  
  207. FUNCTION CallDBQueryDefProc(VAR sessID: LONGINT; query: QueryHandle; userRoutine: DBQueryDefUPP): OSErr;
  208.     {$IFC NOT GENERATINGCFM}
  209.     INLINE $205F, $4E90;
  210.     {$ENDC}
  211.  
  212. FUNCTION CallDBStatusProc(message: INTEGER; result: OSErr; dataLen: INTEGER; dataPlaces: INTEGER; dataFlags: INTEGER; dataType: DBType; dataPtr: Ptr; userRoutine: DBStatusUPP): BOOLEAN;
  213.     {$IFC NOT GENERATINGCFM}
  214.     INLINE $205F, $4E90;
  215.     {$ENDC}
  216.  
  217. FUNCTION CallDBResultHandlerProc(dataType: DBType; theLen: INTEGER; thePlaces: INTEGER; theFlags: INTEGER; theData: Ptr; theText: Handle; userRoutine: DBResultHandlerUPP): OSErr;
  218.     {$IFC NOT GENERATINGCFM}
  219.     INLINE $205F, $4E90;
  220.     {$ENDC}
  221.  
  222. FUNCTION InitDBPack: OSErr;
  223.     {$IFC NOT GENERATINGCFM}
  224.     INLINE $3F3C, $0004, $303C, $0100, $A82F;
  225.     {$ENDC}
  226. FUNCTION DBInit(VAR sessID: LONGINT; ddevName: ConstStr63Param; host: ConstStr255Param; user: ConstStr255Param; passwd: ConstStr255Param; connStr: ConstStr255Param; asyncPB: DBAsyncParmBlkPtr): OSErr;
  227.     {$IFC NOT GENERATINGCFM}
  228.     INLINE $303C, $0E02, $A82F;
  229.     {$ENDC}
  230. FUNCTION DBEnd(sessID: LONGINT; asyncPB: DBAsyncParmBlkPtr): OSErr;
  231.     {$IFC NOT GENERATINGCFM}
  232.     INLINE $303C, $0403, $A82F;
  233.     {$ENDC}
  234. FUNCTION DBGetConnInfo(sessID: LONGINT; sessNum: INTEGER; VAR returnedID: LONGINT; VAR version: LONGINT; VAR ddevName: Str63; VAR host: Str255; VAR user: Str255; VAR network: Str255; VAR connStr: Str255; VAR start: LONGINT; VAR state: OSErr; asyncPB: DBAsyncParmBlkPtr): OSErr;
  235.     {$IFC NOT GENERATINGCFM}
  236.     INLINE $303C, $1704, $A82F;
  237.     {$ENDC}
  238. FUNCTION DBGetSessionNum(sessID: LONGINT; VAR sessNum: INTEGER; asyncPB: DBAsyncParmBlkPtr): OSErr;
  239.     {$IFC NOT GENERATINGCFM}
  240.     INLINE $303C, $0605, $A82F;
  241.     {$ENDC}
  242. FUNCTION DBSend(sessID: LONGINT; text: Ptr; len: INTEGER; asyncPB: DBAsyncParmBlkPtr): OSErr;
  243.     {$IFC NOT GENERATINGCFM}
  244.     INLINE $303C, $0706, $A82F;
  245.     {$ENDC}
  246. FUNCTION DBSendItem(sessID: LONGINT; dataType: DBType; len: INTEGER; places: INTEGER; flags: INTEGER; buffer: UNIV Ptr; asyncPB: DBAsyncParmBlkPtr): OSErr;
  247.     {$IFC NOT GENERATINGCFM}
  248.     INLINE $303C, $0B07, $A82F;
  249.     {$ENDC}
  250. FUNCTION DBExec(sessID: LONGINT; asyncPB: DBAsyncParmBlkPtr): OSErr;
  251.     {$IFC NOT GENERATINGCFM}
  252.     INLINE $303C, $0408, $A82F;
  253.     {$ENDC}
  254. FUNCTION DBState(sessID: LONGINT; asyncPB: DBAsyncParmBlkPtr): OSErr;
  255.     {$IFC NOT GENERATINGCFM}
  256.     INLINE $303C, $0409, $A82F;
  257.     {$ENDC}
  258. FUNCTION DBGetErr(sessID: LONGINT; VAR err1: LONGINT; VAR err2: LONGINT; VAR item1: Str255; VAR item2: Str255; VAR errorMsg: Str255; asyncPB: DBAsyncParmBlkPtr): OSErr;
  259.     {$IFC NOT GENERATINGCFM}
  260.     INLINE $303C, $0E0A, $A82F;
  261.     {$ENDC}
  262. FUNCTION DBBreak(sessID: LONGINT; abort: BOOLEAN; asyncPB: DBAsyncParmBlkPtr): OSErr;
  263.     {$IFC NOT GENERATINGCFM}
  264.     INLINE $303C, $050B, $A82F;
  265.     {$ENDC}
  266. FUNCTION DBGetItem(sessID: LONGINT; timeout: LONGINT; VAR dataType: DBType; VAR len: INTEGER; VAR places: INTEGER; VAR flags: INTEGER; buffer: UNIV Ptr; asyncPB: DBAsyncParmBlkPtr): OSErr;
  267.     {$IFC NOT GENERATINGCFM}
  268.     INLINE $303C, $100C, $A82F;
  269.     {$ENDC}
  270. FUNCTION DBUnGetItem(sessID: LONGINT; asyncPB: DBAsyncParmBlkPtr): OSErr;
  271.     {$IFC NOT GENERATINGCFM}
  272.     INLINE $303C, $040D, $A82F;
  273.     {$ENDC}
  274. FUNCTION DBKill(asyncPB: DBAsyncParmBlkPtr): OSErr;
  275.     {$IFC NOT GENERATINGCFM}
  276.     INLINE $303C, $020E, $A82F;
  277.     {$ENDC}
  278. FUNCTION DBGetNewQuery(queryID: INTEGER; VAR query: QueryHandle): OSErr;
  279.     {$IFC NOT GENERATINGCFM}
  280.     INLINE $303C, $030F, $A82F;
  281.     {$ENDC}
  282. FUNCTION DBDisposeQuery(query: QueryHandle): OSErr;
  283.     {$IFC NOT GENERATINGCFM}
  284.     INLINE $303C, $0210, $A82F;
  285.     {$ENDC}
  286. FUNCTION DBStartQuery(VAR sessID: LONGINT; query: QueryHandle; statusProc: DBStatusUPP; asyncPB: DBAsyncParmBlkPtr): OSErr;
  287.     {$IFC NOT GENERATINGCFM}
  288.     INLINE $303C, $0811, $A82F;
  289.     {$ENDC}
  290. FUNCTION DBGetQueryResults(sessID: LONGINT; VAR results: ResultsRecord; timeout: LONGINT; statusProc: DBStatusUPP; asyncPB: DBAsyncParmBlkPtr): OSErr;
  291.     {$IFC NOT GENERATINGCFM}
  292.     INLINE $303C, $0A12, $A82F;
  293.     {$ENDC}
  294. FUNCTION DBResultsToText(VAR results: ResultsRecord; VAR theText: Handle): OSErr;
  295.     {$IFC NOT GENERATINGCFM}
  296.     INLINE $303C, $0413, $A82F;
  297.     {$ENDC}
  298. FUNCTION DBInstallResultHandler(dataType: DBType; theHandler: DBResultHandlerUPP; isSysHandler: BOOLEAN): OSErr;
  299.     {$IFC NOT GENERATINGCFM}
  300.     INLINE $303C, $0514, $A82F;
  301.     {$ENDC}
  302. FUNCTION DBRemoveResultHandler(dataType: DBType): OSErr;
  303.     {$IFC NOT GENERATINGCFM}
  304.     INLINE $303C, $0215, $A82F;
  305.     {$ENDC}
  306. FUNCTION DBGetResultHandler(dataType: DBType; VAR theHandler: DBResultHandlerUPP; getSysHandler: BOOLEAN): OSErr;
  307.     {$IFC NOT GENERATINGCFM}
  308.     INLINE $303C, $0516, $A82F;
  309.     {$ENDC}
  310.  
  311. {$ALIGN RESET}
  312. {$POP}
  313.  
  314. {$SETC UsingIncludes := DatabaseAccessIncludes}
  315.  
  316. {$ENDC} {__DATABASEACCESS__}
  317.  
  318. {$IFC NOT UsingIncludes}
  319.  END.
  320. {$ENDC}
  321.